\chapter{RGtk2 : le package pour faire des interfaces graphiques en R}
\section{Applications d'exemples}
\paragraph{}
Ce projet de recherche devant se placer dans la continuité, nous allons réaliser plusieurs petites applications pour pouvoir laisser à ceux qui nous succéderons une voie à suivre pour implémenter Explorer3D avec RGtk2, car comme nous l'avons déjà évoqué RGtk2 semble être un package viable pour un portage sous R.

\paragraph{}
Nous allons réaliser plusieurs petites applications qui ne serons pas forcément des plus compliquées, mais qui nous permettrons de mettre en avant tous les concepts nécessaires pour développer une interface graphique à l'aide de l'outil RGtk2.

\paragraph{}
Dans un second temps, il serait souhaitable de pouvoir visualiser les données que l'utilisateur chargera depuis un fichier.
L'idéal serait de pouvoir lancer une fenêtre 3D avec les objets chargés, cela ferait une connexion avec la partie visualisation 3D de ce TER.

\paragraph{}
Nous allons maintenant décrire les différentes applications que nous allons développer par la suite : tout d'abord une application banale, l'équivalent du bien connu "hello world", c'est à dire une application qui ouvre juste une fenêtre vide. Ce n'est pas forcément la plus pertinente des applications, toutefois elle permet de faire un premier pas dans RGtk2.

\paragraph{}
Ensuite nous développerons une petite fenêtre avec un exemple de déploiement de quelques Widgets. Cette fenêtre simple permettra de montrer quelle est la marche à suivre pour créer les différents composants, les configurer, les placer dans la fenêtre et parfois les compléter avec du contenu (notamment pour les listes ou le gestionnaire d'onglets). \\
Encore une fois ce n'est pas forcément la plus compliquée des applications, mais elle permet de faire un tour des possibilités de RGtk2.\\

\paragraph{}
Nous souhaitions aussi pouvoir tester les événements, pour cela nous proposons une troisième application simple avec une interface pour charger un fichier (des champs de texte, des checkbox, des boutons, pour renseigner les options de chargements). Le but étant de pouvoir charger le fichier depuis l'interface et ensuite de pouvoir récupérer les données dans la console. Même si le but d'une interface est que l’utilisateur n'ai plus à se servir de la console, si nous sommes en mesure de récupérer les données chargées depuis un fichier, elles seront accessibles par n'importe quel module de l'application. Nous voulons que les données ainsi chargées aient une existence "globale", car dans R les variables locales utilisées par des fonctions sont instantanément effacées à la fin de l'exécution de la fonction.

\paragraph{}
Et pour finir nous essayerons d'avancer le plus loin possible dans le portage d'Explorer3D sous R, dans cette partie nous allons nous concentrer sur la partie RGtk2 (et donc interface utilisateur) du portage.

\section{RGtk2}
\paragraph{} 
Ces applications ne font  pas partie des plus compliquées, toutefois elles demandent la mise en place de plusieurs aspects de RGtk. On peux en effet noter que cette tache nous permet d'aborder les méthodes de placements des objets dans la fenêtre et donc de voir comment ce concept est géré sous RGtk2.

\paragraph{}
De plus, elles permettent d'aborder le placement des différents composants graphiques tels que les boutons, les checkboxs, et les champs texte, ainsi que les autres Widgets nécessaires au développement d'une interface complexe .\\
De ces composants graphiques naît un besoin : gérer les événements. Nous allons donc aussi explorer ce coté de RGtk2 au travers de ces applications et voir comment envoyer un signal quand un événement se produit et comment appliquer des comportements à ces événements.\\
\newpage

\chapter{Comment fonctionne RGtk2}
\section{Fenêtres et conteneurs}
\paragraph{} 
D'après ce que nous avons pu tester jusqu'à présent, RGtk2 se base sur des conteneurs , qui sont soit verticaux (Vbox) soit horizontaux (Hbox), et ces conteneurs s'imbriquent les uns dans les autres, eux même contenus dans une fenêtre (window). C'est dans ces Box que nous pouvons ensuite ajouter des composants graphiques.

\paragraph{}
Dans la figure suivante, on peut voir la window et une frame (grâce au titre de la frame, RGtk2 affiche un cadre autour de la frame (l'onglet courant).\\

\begin{center}
\includegraphics[scale=0.5]{fenetreVide.png}
\end{center}

\paragraph{} 
Pour obtenir la figure ci-dessus, il suffit du code suivant :\\

\begin{center}
\includegraphics[scale=0.5]{exempleCode.png}
\end{center}

\paragraph{}
On constate qu'un code très court nous permet de faire un premier pas dans RGtk2. Nous pourrions remplacer "window["title"]" qui signifie la colonne titre du vecteur window (car oui , en R tout n'est que vecteur), par windows\$title, qui a le meme effet, celui de renvoyer vers le titre de la fenetre.

\paragraph{}
Nous allons maintenant parler de la bonne façon de construire une interface avec RGtk, en effet il existe une structure "type" qu'il est judicieux de respecter. Bien entendu nous modifierons cette structure pour l'adapter au besoin, mais elle donne un aperçu d'une interface en RGtk2.\\
\begin{center}
\includegraphics[scale=0.5]{structureType.png}
\end{center}

\paragraph{}
Sur la figure précédente, vous pouvez voir sur la gauche une fenêtre avec son rendu graphique, et sur la droite la disposition des différents conteneurs et contenus qui la composent. On a ainsi un exemple d'architecture pour toute interface utilisateur.

\paragraph{}
Nous pouvons donc affirmer que RGtk2 apporte une réponse aux problématiques de gestion des fenêtres ainsi que la gestion de leur contenu, en effet RGtk2 permet au développeur de créer simplement (ou du moins pas si difficilement) une fenêtre qui permettra l'affichage de composants graphiques et widgets indispensables aux interactions avec l'utilisateur.
\newpage
\section{Boutons, checkboxs, labels et Champs de texte}
\paragraph{} 
Nous allons maintenant présenter les boutons, checkboxs et autres gadgets pour interagir avec R depuis l'interface utilisateur. \\
Comme la plupart des systèmes de création d'interfaces graphiques, RGtk2 propose un certain nombre de composants qu'il suffit de paramètrer, pour ensuite les ajouter dans une HBox ou VBox suivant l'alignement recherché.

\paragraph{}
Nous avons trouvé une liste complète des Widgets offerts par RGtk2, cette liste contient quelques objets Deprecated, mais offre une première vue sur les objets disponibles. Elle permet ainsi aux développeurs de choisir l'objet le plus adapté à la situation.\\
\newpage
\textbf{GtkObject}
\\ +GtkWidget
\\  | +GtkMisc
\\  | | +GtkLabel
\\  | | | +GtkAccelLabel
\\  | | | `GtkTipsQuery
\\  | | +GtkArrow
\\  | | +GtkImage
\\  | | `GtkPixmap
\\  | +GtkContainer
\\  | | +GtkBin
\\  | | | +GtkAlignment
\\  | | | +GtkFrame
\\  | | | | `GtkAspectFrame
\\  | | | +GtkButton
\\  | | | | +GtkToggleButton
\\  | | | | | `GtkCheckButton
\\  | | | | |   `GtkRadioButton
\\  | | | | `GtkOptionMenu
\\  | | | +GtkItem
\\  | | | | +GtkMenuItem
\\  | | | | | +GtkCheckMenuItem
\\  | | | | | | `GtkRadioMenuItem
\\  | | | | | `GtkTearoffMenuItem
\\  | | | | +GtkListItem
\\  | | | | `GtkTreeItem
\\  | | | +GtkWindow
\\  | | | | +GtkColorSelectionDialog
\\  | | | | +GtkDialog
\\  | | | | | `GtkInputDialog
\\  | | | | +GtkDrawWindow
\\  | | | | +GtkFileSelection
\\  | | | | +GtkFontSelectionDialog
\\  | | | | `GtkPlug
\\  | | | +GtkEventBox
\\  | | | +GtkHandleBox
\\  | | | +GtkScrolledWindow
\\  | | | `GtkViewport
\newpage
  | | +GtkBox
\\  | | | +GtkButtonBox
\\  | | | | +GtkHButtonBox
\\  | | | | `GtkVButtonBox
\\  | | | +GtkVBox
\\  | | | | +GtkColorSelection
\\  | | | | `GtkGammaCurve
\\  | | | `GtkHBox
\\  | | |   +GtkCombo
\\  | | |   `GtkStatusbar
\\  | | +GtkCList
\\  | | | `GtkCTree
\\  | | +GtkFixed
\\  | | +GtkNotebook
\\  | | | `GtkFontSelection
\\  | | +GtkPaned
\\  | | | +GtkHPaned
\\  | | | `GtkVPaned
\\  | | +GtkLayout
\\  | | +GtkList
\\  | | +GtkMenuShell
\\  | | | +GtkMenuBar
\\  | | | `GtkMenu
\\  | | +GtkPacker
\\  | | +GtkSocket
\\  | | +GtkTable
\\  | | +GtkToolbar
\\  | | `GtkTree
\\  | +GtkCalendar
\\  | +GtkDrawingArea
\\  | | `GtkCurve
\\  | +GtkEditable
\\  | | +GtkEntry
\\  | | | `GtkSpinButton
\\  | | `GtkText
\\  | +GtkRuler
\\  | | +GtkHRuler
\\  | | `GtkVRuler
\\  | +GtkRange
\\  | | +GtkScale
\\  | | | +GtkHScale
\\  | | | `GtkVScale
\\  | | `GtkScrollbar
\\  | |   +GtkHScrollbar
\\  | |   `GtkVScrollbar
\\  | +GtkSeparator
\\  | | +GtkHSeparator
\\  | | `GtkVSeparator
\\  | +GtkPreview
\\  | `GtkProgress
\\  |   `GtkProgressBar
\\  +GtkData
\\  | +GtkAdjustment
\\  | `GtkTooltips
\\  `GtkItemFactory

\newpage
\paragraph{}
Nous avons aussi trouvé une API qui regroupe par widget l'ensemble des fonctions disponibles pour le widget. Celle-ci n'est pas aussi fournie ni aussi claire que l'API Java 6 (pour prendre un exemple bien connu), toutefois elle propose l'ensemble des fonctions disponibles par composants, souvent comment les créer mais aussi : 
\\- comment rajouter des objets dedans dans le cas des conteneurs
\\- comment récupérer leur valeurs pour les champs de texte ou les boutons.

\paragraph{}
Pour prendre un exemple, nous allons montrer la page concernant le gtkNotebook, le widget qui gère plusieurs onglets. \\

\begin{center}
\includegraphics[scale=0.5]{api-notebook.png}
\end{center}

\paragraph{}
Ici chaque fonction est un lien vers une page qui décrit précisément la fonction, permettant ainsi sa mise en œuvre rapide et souvent sans erreur. De plus en cas de mauvaise utilisation d'une fonction, la console R vous informera d'une erreur de manière très précise.

\newpage
\paragraph{}
Nous avons ensuite décidé de construire une petite application simple qui contiendrait la plupart des widgets de base, ainsi que des exemple de contenu (notamment pour le fameux gtkNotebook, classe qui gère les onglets, car la gestion d'onglets semblait être la chose la plus compliquée à faire en RGtk2). \\
Finalement, en cherchant un objet dans la liste et en complétant avec l'API, on peux facilement mettre en place la plupart des composants de base, la création et la gestion des onglets ne se montre pas difficile une fois l'api en main.

\paragraph{}
Voilà le rendu de la fameuse application,\\ 

\begin{center}
\includegraphics[scale=0.4]{simpleFenetre.png}
\end{center}

\paragraph{}
Nous l'avons déjà évoqué, cette application permet de faire un tour rapide des possibilités offertes par RGtk2. Surtout, elle permet de découvrir comment on ajoute des objets dans les conteneurs, et surtout les différents paramètres à spécifier lors de l'ajout.

\paragraph{}
Pour ajouter l'objet X dans le conteneur Y , il suffit de la ligne suivante, 
\begin{lstlisting}
ConteneurY$packStart(ObjectX,expand,fill,padding)
\end{lstlisting}

\paragraph{}
Dans cette ligne, on constate qu'il y a 4 paramètres, le premier plutôt simple, l'objet lui même, ensuite deux booléens : expand et fill, dont les effets sont affichés dans la figure ci-dessous. Le dernier paramètre est le padding, la marge entre le coin de l'objet et le conteneur.\\
\begin{center}
\includegraphics[scale=0.5]{arg_packStart.png}
\end{center}

\paragraph{}
Nous savons maintenant ajouter des objets dans les conteneurs et nous pouvons adapter les objets au style désiré avec cette dernière figure.Il existe cependant des cas plus particuliers dont nous allons maintenant parler, les menus, les ComboBox et les NoteBook.

\section{Les Menus}
\paragraph{}
Nous allons maintenant nous concentrer sur les menus qui sont le cerveau d'une application complexe.
Un menu est fabriqué en quatre étapes où il faut créer une barre de menu, la remplir avec des sous-menus, eux-même remplis avec des objets qui seront connectés à des événements pour engendrer des comportements. Nous verrons dans la sous-section "Événements" comment gérer ces événements. Dans la figure suivante, la structure de menu en RGtk2 est représentée.\\
\begin{center}
\includegraphics[scale=0.5]{structure-menu.png}
\end{center}

\paragraph{}
Dans cette figure, nous pouvons apercevoir que les gtkMenuItem ont plusieurs utilités, car ils sont à la fois les éléments atomiques du menu, mais aussi des conteneurs pour d'autres sous-menus.

\paragraph{}
Pour fabriquer un menu complet, il faut suivre plusieurs étapes. Tout d'abord, il faut créer la MenuBar : 
\begin{lstlisting}
laBarre <- gtkMenuBarNew()
\end{lstlisting}

\paragraph{}
Ensuite il est nécessaire de remplir cette barre avec des menuItem, qui symbolisent les sous-menus. La création et l'ajout de cet objet dans la barre se fait de la façon suivante : 
\begin{lstlisting}
//pour la creation
sousMenuItem <- gtkMenuItemNewWithLabel("SousMenu")
//pour l'ajout
gtkMenuShellAppend(laBarre,sousMenuItem)
\end{lstlisting}
\paragraph{}
Pour le moment ce sous menu est vide, il faut donc pouvoir y ajouter un contenu, sinon ce menu n'a pas de sens. Pour cela, il faut associer les gtkMenuItem qui constituent le sous menu à un gtkMenu, un conteneur spécial qui regroupe des gtkMenuItem, et qui est fait exprès pour être associé à un sous-menu. Nous créons ce fameux conteneur :
\begin{lstlisting}
leSousMenu <- gtkMenuNew()
\end{lstlisting}
\paragraph{}
Ensuite nous créons les éléments du sous-menu :
\begin{lstlisting}
elem1 <- gtkMenuItemNewWithLabel("element un")
elem2 <- gtkMenuItemNewWithLabel("element deux")
\end{lstlisting}
\paragraph{}
Et pour finir nous devons les ajouter dans le sous-menu , toujours avec \\\textbf{gtkMenuShellAppend(menu,élément)}. Enfin, il faut associer ce sous-menu que nous avons créé, au gtkMenuItem qui se trouve dans la barre de menu, cela permettra de voir le sous-menu apparaître lors du clic sur le sous-menu (le gtkMenuItem nommé"SousMenu") dans la barre.
\begin{lstlisting}
gtkMenuItemSetSubmenu(sousMenuItem,leSousMenu)
\end{lstlisting}
\paragraph{}
Il suffit de répéter l'opération pour autant d'objets que souhaité dans la barre ou dans les sous menus.

\paragraph{}
Avec ces quelques lignes nous pouvons voir que RGtk2 répond à la problématique de création des menus, et offre la possibilité de créer des menus complets répondant à des attentes diverses. Nous ne l'avons pas évoqué plus tôt, mais il existe des dérivés des MenuItem, pour créer des objets plus complexes, comme un objet de menu avec une case a cocher, le gtkCheckMenuItem. Il existe aussi un objet avec une image, le gtkImageMenuItem. Cependant nous ne les évoquerons pas tous. Nous n'avons pas eu le temps de les tester, mais ils se comportent de façon analogue.
\newpage

\section{Les ComboBox}
\paragraph{}
Les gtkComboBox sont des listes déroulantes, elles sont paramétrables et conviennent parfaitement dans les cas ou l'utilisateur doit choisir une valeur parmi un ensemble fini. Ces listes permettent d’offrir la possibilité d'une sélection simple ou multiple. Il est même possible d'ajouter des événements au changements de valeurs de la liste. Nous allons maintenant présenter les différentes étapes à suivre pour construire correctement une liste en RGtk2.\\\\

\paragraph{}
Nous allons tout d'abord créer la liste, 
\begin{lstlisting}
notreComboBox = gtkComboBoxNewText()
\end{lstlisting}
\paragraph{}
Ensuite nous la remplissons avec des chaînes de caractères : 
\begin{lstlisting}
gtkComboBoxAppendText(notreComboBox,"chaine1")
gtkComboBoxAppendText(notreComboBox,"chaine2")
\end{lstlisting}

\paragraph{}
Nous avons ici obtenu une liste déroulante qui contient deux chaînes, qui peuvent être récupérées par la suite dans des fonctions.

\paragraph{}
Nous pouvons donc aussi affirmer que RGtk2 répondra aux attentes en termes de gestions des listes à choix multiples, et en se basant sur l'interface d'Explorer3D, c'est un point important que nous savons supporté par l'outil RGtk2.
\newpage

\section{Les NoteBook}
\paragraph{}
Nous allons maintenant parler d'un outil qui permet de gérer plusieurs onglets, il s'appelle gtkNoteBook, et offre au développeur la gestion complètes des onglets. En effet il propose l'ajout, et la suppression de page, leur déplacement (en terme d'ordre dans la liste des pages), mais aussi passer d'une page à une autre sans passer par l'interface utilisateur. Bien entendu, il affiche aussi des labels pour chaque page.\\
Vous avez dans la figure suivante un aperçu de ce que donne graphiquement un NoteBook.
\begin{center}
\includegraphics[scale=0.5]{apercu-notebook.png}\\
\end{center}

\paragraph{}
On peut noter que dans notre exemple nous avons trois onglets, ceux-ci sont nommés par des labels (des chaînes de caractères), et que le premier onglet contient juste un bouton. Toutefois il est possible d'étiqueter les onglets avec d'autres objets que de simples chaînes de caractère , notamment des images, des boutons (même si l'utilité reste encore inconnue),etc... du moment que se sont des descendants de la classe gtkWidget. Le contenu est à encapsuler dans un conteneur classique vu plus haut, mais rien de compliqué.

\paragraph{}
Ces NoteBook ne sont donc finalement pas si difficiles à gérer et offrent au programmeur une gestion totale des actions possibles sur des onglets. Dans un second temps, elles permetent à l'utilisateur d'utiliser un système d'onglet classique et donc de changer dynamiquement le contenu affiché à l'écran. Cet objet propose une solution alternative à la solution classique qui consiste à encapsuler tous les contenus dans un conteneur et à en rendre certains visibles et d'autres invisibles, ce qui est aussi possible en RGtk2. 

\paragraph{}
Avec ces quelques sous-sections, nous avons presque couvert la plupart des composants graphiques. Toutefois, une coquille vide n'est pas satisfaisante. Nous allons donc voir comment engendrer des actions à partir des composants que nous avons mis en place.
\newpage
\section{Événements}
\paragraph{}
Nous allons maintenant nous concentrer sur les évènements, afin de pouvoir créer un comportement dynamique durant l'exécution de l’application. Nous allons voir que RGtk2 gère assez bien les événements. En effet , il utilise les signaux en les connectant à une fonction et un événement pour qu'ils déclenchent la fonction à la levée de l'événement. Il suffit donc de trouver le bon événement et la bonne fonction. Nous n'avons pas exploré tous les types d'événements mais nous sommes quand même parvenu à faire marcher les plus intéressants pour Explorer3D, les événements de clic sur un bouton, et le choix d'un sous menu dans un menu, car ces deux cas sont très présents dans l'interface d'Explorer3D.

\paragraph{}
Pour résumer, il suffit de savoir quel événements va avec quel composant graphique et quel entête la fonction que nous souhaitons connecter doit respecter. Pour cela nous allons d'abord parler du cas général, ensuite nous continuerons sur les boutons et enfin sur les objets d'un menu.

\paragraph{}
Pour connecter un composant à une fonction en RGtk2, rien de plus simple, il suffit de faire : 
\begin{lstlisting}
gSignalConnect(composantGraphique,evenement,fonction, 
					data(optionnel))
\end{lstlisting}

\paragraph{}
Et c'est tout. Cette unique ligne va connecter un composant à une fonction. Toutefois des précisions s'imposent. Cette ligne ne fonctionne que si nous avons une fonction  avec un entête correct et connaissons le bon type d'événement (car événement est une énumération de chaînes de caractères. Les deux seuls que nous connaissons sont: "clicked" et "activate". Nous y reviendrons par la suite). Le paramètre événement est lié au composant, car nous cliquons sur un bouton mais nous activons un sous menu (d'où le clicked et le activate), chose que nous ne savons pas forcément et qui n'est marqué nulle part. La fonction à connecter doit suivre le modèle suivant : 
\begin{lstlisting}
maFonction <- function(objet, user.data){

code de maFonction

}
\end{lstlisting}

\paragraph{}
Ici, objet est générique, mais par convention nous mettons button dans le cas d'un bouton ou item pour un menuItem, pour ne citer que les exemples abordés. Par contre user.data est toujours présent mais fait souvent référence à l'ensemble des variables déjà instanciées avant l'exécution de la fonction. Nous allons maintenant voir comment connecter un bouton et un item à des fonction.

\newpage
\paragraph{}
Supposons nos deux fonctions prédéfinies comme ceci :
\begin{lstlisting}
queFaireSurClicBouton <- function(button,user.data){
}
queFaireActivationItem <- function(item, user.data){
}
\end{lstlisting}

\paragraph{}
Nous allons utiliser la fonction gSignalConnect pour "lier" les fonctions et leur composant
\begin{lstlisting}
gSignalConnect(monBouton,"clicked",queFaireSurClicBouton) #cela connecte le bouton
gSignalConnect(monMenuItem,"activate",queFaireActivationItem)
#celle ci connecte le MenuItem
\end{lstlisting} 
\paragraph{}
Grace à ces deux lignes, la fonction \textit{queFaireSurClicBouton} s'exécute lors d'un clic sur monBouton, et la fonction \textit{queFaireActivationItem} lors d'un clic sur monMenuItem.


\paragraph{}
Nous pouvons donc voir que RGtk2 gère les événements de manière très simple à implémenter, pour peu que nous ayons le bon événement et la bonne fonction. Il répond donc tout à fait aux attentes de réaction d'une interface utilisateur aux agissement de ce dernier. Il est aussi possible de lancer des fonctions lors du changement d'une valeur dans une liste (comboBox). Toutefois ce traitement est plus compliqué et n'a pas été entièrement exploré. Nous n'allons donc pas le développer mais nous savons que ce problème peut être résolu par RGtk2.

\paragraph{}
Pour conclure un peu sur ce fonctionnement de RGtk2, nous allons évoquer les difficultés rencontrées, car même si nous avons beaucoup exploré ce package, il n'a pas été si simple de le faire.
\newpage
\section{Difficultés}
\paragraph{}
Comme tout développement de projet, celui-ci a aussi eu son lot de problèmes. Le principal problème est qu'il n'existe \textbf{pratiquement aucune} documentation. Certes Gtk l'outil dont dépend RGtk2 est très documenté, toutefois son implémentation en R n'as pas été très renseignée, et même internet est pauvre en ressource pour apprendre à se servir de celui-ci. Nous avons dû nous contenter de suivre parfois un instinct, parfois la seule documentation existence - à savoir la page :\textit{http://rss.acs.unt.edu/Rdoc/library/RGtk2/html/} qui regroupe les objets existants dans RGtk2. Dans les cas où nous sommes chanceux, les fonctions liées à cet objet font exactement ce que nous souhaitons, mais c'est assez rare.

\paragraph{}
Une des méthodes alternatives fut de suivre les nombreux tutoriaux présent en Gtk (donc en C) et d'essayer tant bien que mal d'adapter la méthode en R. Néanmoins cette méthode n'est pas si simple car si en C une classe héritière hérite des fonctions de son ancêtre, ce n'est pas le cas en R. Nous sommes obligé d'utiliser une fonction d'une classe ancêtre pour agir sur une classe fille. Ce n'est pas vraiment du code propre mais c’est la seule méthode fonctionnelle.

\paragraph{}
Prenons un exemple, nous savons que la classe menuBar descend de la classe MenuShell. La fonction qui nous intéresse est une fonction qui permet d'ajouter un objet(MenuItem) dans la barre de menu. Il existe une fonction dans le gtkMenuShell qui s'appelle append et qui permet d'ajouter un item dans un menuShell. Idéalement, cette fonction serait aussi dans la classe fille et nous pourrions faire maBarreDeMenu\$append(objetARajouter). En réalité la fonction append n'est pas dans la classe fille, nous sommes obligé de passer par la fonction de classe gtkMenuShellAppend(objetShell,item) pour la rajouter, soit :
\begin{lstlisting}
gtkMenuShellAppend(MaBarre,monObjetAAjouter)
\end{lstlisting}

\paragraph{}
Nous sommes donc obligé d'utiliser une méthode de classe appartenant à gtkMenuShell, la classe ancêtre, pour modifier les attributs d'une gtkMenuBar, une classe fille. Ce n'est pas la seule classe dans ce cas, c'est même presque toujours le cas pour toutes les classes qui héritent d'autres. Cette particularité n’est pas une "vraie" difficulté au sens où elle serait insurmontable. Toutefois elle doit être évoquée car elle multiplie un temps de recherche déjà assez long (à cause du manque de documentation et de la quasi-inexistence d'exemples sur le net) pour faire une opération toute simple sur les composants.
\newpage

